home *** CD-ROM | disk | FTP | other *** search
/ AGA Toolkit '97 / The AGA Toolkit '97.iso / programming / c / make-3.75 / commands.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-07  |  12.5 KB  |  538 lines
  1. /* Command processing for GNU Make.
  2. Copyright (C) 1988, 1989, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
  3. This file is part of GNU Make.
  4.  
  5. GNU Make is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation; either version 2, or (at your option)
  8. any later version.
  9.  
  10. GNU Make is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with GNU Make; see the file COPYING.  If not, write to
  17. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18.  
  19. #include "make.h"
  20. #include "dep.h"
  21. #include "commands.h"
  22. #include "file.h"
  23. #include "variable.h"
  24. #include "job.h"
  25.  
  26. extern int remote_kill ();
  27.  
  28. #ifndef HAVE_UNISTD_H
  29. extern int getpid ();
  30. #endif
  31.  
  32. /* Set FILE's automatic variables up.  */
  33.  
  34. static void
  35. set_file_variables (file)
  36.      register struct file *file;
  37. {
  38.   register char *p;
  39.   char *at, *percent, *star, *less;
  40.  
  41. #ifndef NO_ARCHIVES
  42.   /* If the target is an archive member `lib(member)',
  43.      then $@ is `lib' and $% is `member'.  */
  44.  
  45.   if (ar_name (file->name))
  46.     {
  47.       unsigned int len;
  48.       p = index (file->name, '(');
  49.       at = (char *) alloca (p - file->name + 1);
  50.       bcopy (file->name, at, p - file->name);
  51.       at[p - file->name] = '\0';
  52.       len = strlen (p + 1);
  53.       percent = (char *) alloca (len);
  54.       bcopy (p + 1, percent, len - 1);
  55.       percent[len - 1] = '\0';
  56.     }
  57.   else
  58. #endif    /* NO_ARCHIVES.  */
  59.     {
  60.       at = file->name;
  61.       percent = "";
  62.     }
  63.  
  64.   /* $* is the stem from an implicit or static pattern rule.  */
  65.   if (file->stem == 0)
  66.     {
  67.       /* In Unix make, $* is set to the target name with
  68.      any suffix in the .SUFFIXES list stripped off for
  69.      explicit rules.  We store this in the `stem' member.  */
  70.       register struct dep *d;
  71.       char *name;
  72.       unsigned int len;
  73.  
  74. #ifndef NO_ARCHIVES
  75.       if (ar_name (file->name))
  76.     {
  77.       name = index (file->name, '(') + 1;
  78.       len = strlen (name) - 1;
  79.     }
  80.       else
  81. #endif
  82.     {
  83.       name = file->name;
  84.       len = strlen (name);
  85.     }
  86.  
  87.       for (d = enter_file (".SUFFIXES")->deps; d != 0; d = d->next)
  88.     {
  89.       unsigned int slen = strlen (dep_name (d));
  90.       if (len > slen && !strncmp (dep_name (d), name + (len - slen), slen))
  91.         {
  92.           file->stem = savestring (name, len - slen);
  93.           break;
  94.         }
  95.     }
  96.       if (d == 0)
  97.     file->stem = "";
  98.     }
  99.   star = file->stem;
  100.  
  101.   /* $< is the first dependency.  */
  102.   less = file->deps != 0 ? dep_name (file->deps) : "";
  103.  
  104.   if (file->cmds == default_file->cmds)
  105.     /* This file got its commands from .DEFAULT.
  106.        In this case $< is the same as $@.  */
  107.     less = at;
  108.  
  109. #define DEFINE_VARIABLE(name, len, value) \
  110.   (void) define_variable_for_file (name, len, value, o_automatic, 0, file)
  111.  
  112.   /* Define the variables.  */
  113.  
  114.   DEFINE_VARIABLE ("<", 1, less);
  115.   DEFINE_VARIABLE ("*", 1, star);
  116.   DEFINE_VARIABLE ("@", 1, at);
  117.   DEFINE_VARIABLE ("%", 1, percent);
  118.  
  119.   /* Compute the values for $^, $+, and $?.  */
  120.  
  121.   {
  122.     register unsigned int qmark_len, plus_len;
  123.     char *caret_value, *plus_value;
  124.     register char *cp;
  125.     char *qmark_value;
  126.     register char *qp;
  127.     register struct dep *d;
  128.     unsigned int len;
  129.  
  130.     /* Compute first the value for $+, which is supposed to contain
  131.        duplicate dependencies as they were listed in the makefile.  */
  132.  
  133.     plus_len = 0;
  134.     for (d = file->deps; d != 0; d = d->next)
  135.       plus_len += strlen (dep_name (d)) + 1;
  136.  
  137.     len = plus_len == 0 ? 1 : plus_len;
  138.     cp = plus_value = (char *) alloca (len);
  139.  
  140.     qmark_len = plus_len;    /* Will be this or less.  */
  141.     for (d = file->deps; d != 0; d = d->next)
  142.       {
  143.     char *c = dep_name (d);
  144.  
  145. #ifndef NO_ARCHIVES
  146.     if (ar_name (c))
  147.       {
  148.         c = index (c, '(') + 1;
  149.         len = strlen (c) - 1;
  150.       }
  151.     else
  152. #endif
  153.       len = strlen (c);
  154.  
  155.     bcopy (c, cp, len);
  156.     cp += len;
  157.     *cp++ = ' ';
  158.  
  159.     if (! d->changed)
  160.       qmark_len -= len + 1; /* Don't space in $? for this one.  */
  161.       }
  162.  
  163.     /* Kill the last space and define the variable.  */
  164.  
  165.     cp[cp > plus_value ? -1 : 0] = '\0';
  166.     DEFINE_VARIABLE ("+", 1, plus_value);
  167.  
  168.     /* Make sure that no dependencies are repeated.  This does not
  169.        really matter for the purpose of updating targets, but it
  170.        might make some names be listed twice for $^ and $?.  */
  171.  
  172.     uniquize_deps (file->deps);
  173.  
  174.     /* Compute the values for $^ and $?.  */
  175.  
  176.     cp = caret_value = plus_value; /* Reuse the buffer; it's big enough.  */
  177.     len = qmark_len == 0 ? 1 : qmark_len;
  178.     qp = qmark_value = (char *) alloca (len);
  179.  
  180.     for (d = file->deps; d != 0; d = d->next)
  181.       {
  182.     char *c = dep_name (d);
  183.  
  184. #ifndef NO_ARCHIVES
  185.     if (ar_name (c))
  186.       {
  187.         c = index (c, '(') + 1;
  188.         len = strlen (c) - 1;
  189.       }
  190.     else
  191. #endif
  192.       len = strlen (c);
  193.  
  194.     bcopy (c, cp, len);
  195.     cp += len;
  196.     *cp++ = ' ';
  197.  
  198.     if (d->changed)
  199.       {
  200.         bcopy (c, qp, len);
  201.         qp += len;
  202.         *qp++ = ' ';
  203.       }
  204.       }
  205.  
  206.     /* Kill the last spaces and define the variables.  */
  207.  
  208.     cp[cp > caret_value ? -1 : 0] = '\0';
  209.     DEFINE_VARIABLE ("^", 1, caret_value);
  210.  
  211.     qp[qp > qmark_value ? -1 : 0] = '\0';
  212.     DEFINE_VARIABLE ("?", 1, qmark_value);
  213.   }
  214.  
  215. #undef    DEFINE_VARIABLE
  216. }
  217.  
  218. /* Chop CMDS up into individual command lines if necessary.
  219.    Also set the `lines_flag' and `any_recurse' members.  */
  220.  
  221. void
  222. chop_commands (cmds)
  223.      register struct commands *cmds;
  224. {
  225.   if (cmds != 0 && cmds->command_lines == 0)
  226.     {
  227.       /* Chop CMDS->commands up into lines in CMDS->command_lines.
  228.      Also set the corresponding CMDS->lines_flags elements,
  229.      and the CMDS->any_recurse flag.  */
  230.       register char *p;
  231.       unsigned int nlines, idx;
  232.       char **lines;
  233.  
  234.       nlines = 5;
  235.       lines = (char **) xmalloc (5 * sizeof (char *));
  236.       idx = 0;
  237.       p = cmds->commands;
  238.       while (*p != '\0')
  239.     {
  240.       char *end = p;
  241.     find_end:;
  242.       end = index (end, '\n');
  243.       if (end == 0)
  244.         end = p + strlen (p);
  245.       else if (end > p && end[-1] == '\\')
  246.         {
  247.           int backslash = 1;
  248.           register char *b;
  249.           for (b = end - 2; b >= p && *b == '\\'; --b)
  250.         backslash = !backslash;
  251.           if (backslash)
  252.         {
  253.           ++end;
  254.           goto find_end;
  255.         }
  256.         }
  257.  
  258.       if (idx == nlines)
  259.         {
  260.           nlines += 2;
  261.           lines = (char **) xrealloc ((char *) lines,
  262.                       nlines * sizeof (char *));
  263.         }
  264.       lines[idx++] = savestring (p, end - p);
  265.       p = end;
  266.       if (*p != '\0')
  267.         ++p;
  268.     }
  269.  
  270.       if (idx != nlines)
  271.     {
  272.       nlines = idx;
  273.       lines = (char **) xrealloc ((char *) lines,
  274.                       nlines * sizeof (char *));
  275.     }
  276.  
  277.       cmds->ncommand_lines = nlines;
  278.       cmds->command_lines = lines;
  279.  
  280.       cmds->any_recurse = 0;
  281.       cmds->lines_flags = (char *) xmalloc (nlines);
  282.       for (idx = 0; idx < nlines; ++idx)
  283.     {
  284.       int flags = 0;
  285.  
  286.       for (p = lines[idx];
  287.            isblank (*p) || *p == '-' || *p == '@' || *p == '+';
  288.            ++p)
  289.         switch (*p)
  290.           {
  291.           case '+':
  292.         flags |= COMMANDS_RECURSE;
  293.         break;
  294.           case '@':
  295.         flags |= COMMANDS_SILENT;
  296.         break;
  297.           case '-':
  298.         flags |= COMMANDS_NOERROR;
  299.         break;
  300.           }
  301.       if (!(flags & COMMANDS_RECURSE))
  302.         {
  303.           unsigned int len = strlen (p);
  304.           if (sindex (p, len, "$(MAKE)", 7) != 0
  305.           || sindex (p, len, "${MAKE}", 7) != 0)
  306.         flags |= COMMANDS_RECURSE;
  307.         }
  308.  
  309.       cmds->lines_flags[idx] = flags;
  310.       cmds->any_recurse |= flags & COMMANDS_RECURSE;
  311.     }
  312.     }
  313. }
  314.  
  315. /* Execute the commands to remake FILE.  If they are currently executing,
  316.    return or have already finished executing, just return.  Otherwise,
  317.    fork off a child process to run the first command line in the sequence.  */
  318.  
  319. void
  320. execute_file_commands (file)
  321.      struct file *file;
  322. {
  323.   register char *p;
  324.  
  325.   /* Don't go through all the preparations if
  326.      the commands are nothing but whitespace.  */
  327.  
  328.   for (p = file->cmds->commands; *p != '\0'; ++p)
  329.     if (!isspace (*p) && *p != '-' && *p != '@')
  330.       break;
  331.   if (*p == '\0')
  332.     {
  333.       /* We are all out of commands.
  334.      If we have gotten this far, all the previous commands
  335.      have run successfully, so we have winning update status.  */
  336.       file->update_status = 0;
  337.       notice_finished_file (file);
  338.       return;
  339.     }
  340.  
  341.   /* First set the automatic variables according to this file.    */
  342.  
  343.   initialize_file_variables (file);
  344.  
  345.   set_file_variables (file);
  346.  
  347.   /* Start the commands running.  */
  348.   new_job (file);
  349. }
  350.  
  351. /* This is set while we are inside fatal_error_signal,
  352.    so things can avoid nonreentrant operations.  */
  353.  
  354. int handling_fatal_signal = 0;
  355.  
  356. /* Handle fatal signals.  */
  357.  
  358. RETSIGTYPE
  359. fatal_error_signal (sig)
  360.      int sig;
  361. {
  362. #if defined(__MSDOS__) || defined(_AMIGA)
  363.   remove_intermediates (1);
  364. #ifdef _AMIGA
  365.   if (sig == SIGINT)
  366.      fputs ("*** Break.\n", stderr);
  367.  
  368.   exit (10);
  369. #else
  370.   exit (1);
  371. #endif
  372. #else    /* Not MSDOS.  */
  373.   handling_fatal_signal = 1;
  374.  
  375.   /* Set the handling for this signal to the default.
  376.      It is blocked now while we run this handler.  */
  377.   signal (sig, SIG_DFL);
  378.  
  379.   /* A termination signal won't be sent to the entire
  380.      process group, but it means we want to kill the children.    */
  381.  
  382.   if (sig == SIGTERM)
  383.     {
  384.       register struct child *c;
  385.       for (c = children; c != 0; c = c->next)
  386.     if (!c->remote)
  387.       (void) kill (c->pid, SIGTERM);
  388.     }
  389.  
  390.   /* If we got a signal that means the user
  391.      wanted to kill make, remove pending targets.  */
  392.  
  393.   if (sig == SIGTERM || sig == SIGINT
  394. #ifdef SIGHUP
  395.     || sig == SIGHUP
  396. #endif
  397. #ifdef SIGQUIT
  398.     || sig == SIGQUIT
  399. #endif
  400.     )
  401.     {
  402.       register struct child *c;
  403.  
  404.       /* Remote children won't automatically get signals sent
  405.      to the process group, so we must send them.  */
  406.       for (c = children; c != 0; c = c->next)
  407.     if (c->remote)
  408.       (void) remote_kill (c->pid, sig);
  409.  
  410.       for (c = children; c != 0; c = c->next)
  411.     delete_child_targets (c);
  412.  
  413.       /* Clean up the children.  We don't just use the call below because
  414.      we don't want to print the "Waiting for children" message.  */
  415.       while (job_slots_used > 0)
  416.     reap_children (1, 0);
  417.     }
  418.   else
  419.     /* Wait for our children to die.  */
  420.     while (job_slots_used > 0)
  421.       reap_children (1, 1);
  422.  
  423.   /* Delete any non-precious intermediate files that were made.  */
  424.  
  425.   remove_intermediates (1);
  426.  
  427. #ifdef SIGQUIT
  428.   if (sig == SIGQUIT)
  429.     /* We don't want to send ourselves SIGQUIT, because it will
  430.        cause a core dump.  Just exit instead.  */
  431.     exit (1);
  432. #endif
  433.  
  434.   /* Signal the same code; this time it will really be fatal.  The signal
  435.      will be unblocked when we return and arrive then to kill us.  */
  436.   if (kill (getpid (), sig) < 0)
  437.     pfatal_with_name ("kill");
  438. #endif    /* MSDOS.  */
  439. }
  440.  
  441. /* Delete FILE unless it's precious or not actually a file (phony),
  442.    and it has changed on disk since we last stat'd it.  */
  443.  
  444. static void
  445. delete_target (file, on_behalf_of)
  446.      struct file *file;
  447.      char *on_behalf_of;
  448. {
  449.   struct stat st;
  450.  
  451.   if (file->precious || file->phony)
  452.     return;
  453.  
  454. #ifndef NO_ARCHIVES
  455.   if (ar_name (file->name))
  456.     {
  457.       if (ar_member_date (file->name) != file->last_mtime)
  458.     {
  459.       if (on_behalf_of)
  460.         error ("*** [%s] Archive member `%s' may be bogus; not deleted",
  461.            on_behalf_of, file->name);
  462.       else
  463.         error ("*** Archive member `%s' may be bogus; not deleted",
  464.            file->name);
  465.     }
  466.       return;
  467.     }
  468. #endif
  469.  
  470.   if (safe_stat (file->name, &st) == 0
  471.       && S_ISREG (st.st_mode)
  472.       && (time_t) st.st_mtime != file->last_mtime)
  473.     {
  474.       if (on_behalf_of)
  475.     error ("*** [%s] Deleting file `%s'", on_behalf_of, file->name);
  476.       else
  477.     error ("*** Deleting file `%s'", file->name);
  478.       if (unlink (file->name) < 0)
  479.     perror_with_name ("unlink: ", file->name);
  480.     }
  481. }
  482.  
  483.  
  484. /* Delete all non-precious targets of CHILD unless they were already deleted.
  485.    Set the flag in CHILD to say they've been deleted.  */
  486.  
  487. void
  488. delete_child_targets (child)
  489.      struct child *child;
  490. {
  491.   struct dep *d;
  492.  
  493.   if (child->deleted)
  494.     return;
  495.  
  496.   /* Delete the target file if it changed.  */
  497.   delete_target (child->file, (char *) 0);
  498.  
  499.   /* Also remove any non-precious targets listed in the `also_make' member.  */
  500.   for (d = child->file->also_make; d != 0; d = d->next)
  501.     delete_target (d->file, child->file->name);
  502.  
  503.   child->deleted = 1;
  504. }
  505.  
  506. /* Print out the commands in CMDS.  */
  507.  
  508. void
  509. print_commands (cmds)
  510.      register struct commands *cmds;
  511. {
  512.   register char *s;
  513.  
  514.   fputs ("#  commands to execute", stdout);
  515.  
  516.   if (cmds->filename == 0)
  517.     puts (" (built-in):");
  518.   else
  519.     printf (" (from `%s', line %u):\n", cmds->filename, cmds->lineno);
  520.  
  521.   s = cmds->commands;
  522.   while (*s != '\0')
  523.     {
  524.       char *end;
  525.  
  526.       while (isspace (*s))
  527.     ++s;
  528.  
  529.       end = index (s, '\n');
  530.       if (end == 0)
  531.     end = s + strlen (s);
  532.  
  533.       printf ("\t%.*s\n", (int) (end - s), s);
  534.  
  535.       s = end;
  536.     }
  537. }
  538.